package com.school.sports.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.school.sports.entity.Award;
import com.school.sports.service.AwardService;
import com.school.sports.common.Result;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

/**
 * 奖项控制器
 * 处理与奖项相关的HTTP请求，提供奖项的增删改查功能
 */
@RestController
@RequestMapping("/award")
public class AwardController {

    // 日志记录器
    private static final Logger logger = LoggerFactory.getLogger(AwardController.class);

    // 注入奖项服务
    @Autowired
    private AwardService awardService;

    /**
     * 分页查询和条件查询奖项
     * @param currentPage 当前页码
     * @param pageSize 每页显示数量
     * @param award 奖项对象，用于传递查询条件
     * @return 包含分页数据的Result对象
     */
    @GetMapping("/page/{currentPage}/{pageSize}")
    public Result<IPage<Award>> getAwardPage(
            @PathVariable("currentPage") Integer currentPage,
            @PathVariable("pageSize") Integer pageSize,
            Award award) {

        logger.info("分页查询奖项，当前页码:{}，每页条数：{}，查询条件：{}", currentPage, pageSize, award);

        // 参数校验
        if (currentPage == null || currentPage <= 0) {
            currentPage = 1;
        }
        if (pageSize == null || pageSize <= 0) {
            pageSize = 10;
        }

        // 调用服务层方法获取分页数据
        IPage<Award> page = awardService.getPage(currentPage, pageSize, award);

        // 如果当前页码超过总页数，获取最后一页数据
        if (currentPage > page.getPages() && page.getPages() > 0) {
            page = awardService.getPage((int) page.getPages(), pageSize, award);
        }

        logger.info("查询成功，共{}条记录，当前第{}页", page.getTotal(), page.getCurrent());

        // 返回成功结果，包含分页数据
        return Result.success(page);
    }

    /**
     * 根据ID查询单个奖项
     * @param id 奖项ID
     * @return 包含奖项详情的Result对象
     */
    @GetMapping("/detail/{id}")
    public Result<Award> getAwardById(@PathVariable("id") Long id) {
        logger.info("根据ID查询奖项详情，ID：{}", id);

        // 参数校验
        if (id == null || id <= 0) {
            logger.warn("查询失败：奖项ID无效");
            return Result.fail("查询失败：奖项ID无效");
        }

        try {
            // 根据ID查询奖项
            Award award = awardService.getById(id);

            if (award == null) {
                logger.warn("未找到ID为{}的奖项", id);
                return Result.fail("未找到对应的奖项记录");
            }

            logger.info("查询奖项详情成功，ID：{}", id);
            return Result.success(award);
        } catch (Exception e) {
            logger.error("查询奖项详情异常：{}", e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 按条件查询奖项列表
     * @param userId 用户ID（可选）
     * @param projectId 项目ID（可选）
     * @param awardLevel 奖项等级（可选）
     * @return 包含奖项列表的Result对象
     */
    @GetMapping("/list")
    public Result<List<Award>> getAwardList(
            @RequestParam(required = false) Long userId,
            @RequestParam(required = false) Long projectId,
            @RequestParam(required = false) String awardLevel) {

        logger.info("按条件查询奖项列表，用户ID：{}，项目ID：{}，奖项等级：{}", userId, projectId, awardLevel);

        try {
            // 构建查询条件
            Award queryAward = new Award();
            queryAward.setUserId(userId);
            queryAward.setProjectId(projectId);
            queryAward.setAwardLevel(awardLevel);

            // 调用服务层方法查询奖项列表
            List<Award> awardList = awardService.listByCondition(queryAward);

            logger.info("查询奖项列表成功，共{}条记录", awardList.size());
            return Result.success(awardList);
        } catch (Exception e) {
            logger.error("查询奖项列表异常：{}", e.getMessage(), e);
            return Result.fail("查询失败：" + e.getMessage());
        }
    }

    /**
     * 添加一个奖项
     * @param award 奖项对象，包含要添加的奖项信息
     * @return 操作结果信息
     */
    @PostMapping
    public Result<String> addAward(@Valid @RequestBody Award award) {
        try {
            logger.info("添加奖项：{}", award);

            // 调用服务层方法保存奖项
            boolean saveResult = awardService.save(award);

            if (saveResult) {
                logger.info("奖项添加成功");
                return Result.success("添加成功");
            } else {
                logger.warn("奖项添加失败");
                return Result.fail("添加失败：保存操作未成功");
            }
        } catch (Exception e) {
            logger.error("添加奖项异常：{}", e.getMessage(), e);
            // 捕获异常并返回添加失败的结果
            return Result.fail("添加失败：" + e.getMessage());
        }
    }

    /**
     * 修改奖项信息
     * @param award 奖项对象，包含要修改的奖项信息
     * @return 操作结果信息
     */
    @PutMapping
    public Result<String> updateAward(@Valid @RequestBody Award award) {
        try {
            logger.info("修改奖项：{}", award);

            // 参数校验
            if (award.getId() == null || award.getId() <= 0) {
                logger.warn("修改失败：奖项ID无效");
                return Result.fail("修改失败：奖项ID无效");
            }

            // 调用服务层方法更新奖项
            boolean updateResult = awardService.updateById(award);

            if (updateResult) {
                logger.info("奖项修改成功，ID：{}", award.getId());
                return Result.success("修改成功");
            } else {
                logger.warn("奖项修改失败，ID：{}", award.getId());
                return Result.fail("修改失败：更新操作未成功");
            }
        } catch (Exception e) {
            logger.error("修改奖项异常：{}", e.getMessage(), e);
            return Result.fail("修改失败：" + e.getMessage());
        }
    }

    /**
     * 根据ID删除奖项
     * @param id 奖项ID
     * @return 操作结果信息
     */
    @DeleteMapping("/{id}")
    public Result<String> deleteAward(@PathVariable("id") Long id) {
        logger.info("删除奖项，ID：{}", id);

        // 参数校验
        if (id == null || id <= 0) {
            logger.warn("删除失败：奖项ID无效");
            return Result.fail("删除失败：奖项ID无效");
        }

        try {
            // 调用服务层方法删除奖项
            boolean removeResult = awardService.removeById(id);

            if (removeResult) {
                logger.info("奖项删除成功，ID：{}", id);
                return Result.success("删除成功");
            } else {
                logger.warn("奖项删除失败，ID：{}", id);
                return Result.fail("删除失败：未找到对应的奖项记录");
            }
        } catch (Exception e) {
            logger.error("删除奖项异常：{}", e.getMessage(), e);
            return Result.fail("删除失败：" + e.getMessage());
        }
    }
}